const { app, BrowserWindow, Menu, shell, dialog, ipcMain } = require('electron');
const path = require('path');
const { spawn, exec } = require('child_process');
const fs = require('fs');
const net = require('net');

// 保持对窗口对象的全局引用，如果不这样做，当JavaScript对象被垃圾回收时，窗口将自动关闭
let mainWindow;
let serverProcess;

/**
 * 检查端口是否被占用
 * @param {number} port 端口号
 * @returns {Promise<boolean>} 端口是否被占用
 */
function checkPortInUse(port) {
  return new Promise((resolve) => {
    const server = net.createServer();
    
    server.listen(port, () => {
      server.once('close', () => {
        resolve(false); // 端口未被占用
      });
      server.close();
    });
    
    server.on('error', () => {
      resolve(true); // 端口被占用
    });
  });
}

/**
 * 查找占用指定端口的进程PID
 * @param {number} port 端口号
 * @returns {Promise<string[]>} 进程PID列表
 */
function findProcessByPort(port) {
  return new Promise((resolve, reject) => {
    // 使用netstat命令查找占用端口的进程
    exec(`netstat -ano | findstr :${port}`, (error, stdout, stderr) => {
      if (error) {
        resolve([]); // 没有找到进程
        return;
      }
      
      const lines = stdout.split('\n');
      const pids = [];
      
      lines.forEach(line => {
        const parts = line.trim().split(/\s+/);
        if (parts.length >= 5 && parts[1].includes(`:${port}`)) {
          const pid = parts[4];
          if (pid && pid !== '0' && !pids.includes(pid)) {
            pids.push(pid);
          }
        }
      });
      
      resolve(pids);
    });
  });
}

/**
 * 停止指定PID的进程
 * @param {string} pid 进程ID
 * @returns {Promise<boolean>} 是否成功停止
 */
function killProcess(pid) {
  return new Promise((resolve) => {
    exec(`taskkill /F /PID ${pid}`, (error, stdout, stderr) => {
      if (error) {
        console.log(`⚠️ 无法停止进程 ${pid}: ${error.message}`);
        resolve(false);
      } else {
        console.log(`✅ 成功停止进程 ${pid}`);
        resolve(true);
      }
    });
  });
}

/**
 * 等待指定时间
 * @param {number} ms 毫秒数
 */
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// 启动后端服务器
async function startServer() {
  const PORT = 3001;
  const serverPath = path.join(__dirname, 'src', 'server.js');
  console.log(`尝试启动服务器: ${serverPath}`);
  
  // 检查服务器文件是否存在
  if (!fs.existsSync(serverPath)) {
    const error = new Error(`服务器文件不存在: ${serverPath}`);
    console.error(error.message);
    throw error;
  }

  // 检查端口是否被占用
  console.log(`🔍 检查端口 ${PORT} 是否被占用...`);
  const isPortInUse = await checkPortInUse(PORT);
  
  if (isPortInUse) {
    console.log(`⚠️ 端口 ${PORT} 已被占用，正在查找占用进程...`);
    
    const pids = await findProcessByPort(PORT);
    
    if (pids.length > 0) {
      console.log(`📋 找到 ${pids.length} 个占用端口的进程: ${pids.join(', ')}`);
      
      // 停止所有占用端口的进程
      for (const pid of pids) {
        await killProcess(pid);
      }
      
      // 等待进程完全停止
      console.log('⏳ 等待进程完全停止...');
      await sleep(2000);
      
      // 再次检查端口是否释放
      const stillInUse = await checkPortInUse(PORT);
      if (stillInUse) {
        const error = new Error(`端口 ${PORT} 仍被占用，请手动检查并停止相关进程`);
        console.log(`❌ ${error.message}`);
        throw error;
      } else {
        console.log(`✅ 端口 ${PORT} 已释放`);
      }
    } else {
      console.log(`⚠️ 无法找到占用端口 ${PORT} 的进程，可能是系统进程或权限不足`);
      const error = new Error('请手动检查并停止相关进程，或使用其他端口');
      throw error;
    }
  } else {
    console.log(`✅ 端口 ${PORT} 可用`);
  }

  return new Promise((resolve, reject) => {

    serverProcess = spawn('node', [serverPath], {
      stdio: 'pipe',
      env: { ...process.env, PORT: '3001' },
      cwd: __dirname
    });

    let serverStarted = false;

    serverProcess.stdout.on('data', (data) => {
      const output = data.toString();
      console.log(`Server: ${output}`);
      if (output.includes('Server running on port') && !serverStarted) {
        serverStarted = true;
        console.log('服务器启动成功确认');
        resolve();
      }
    });

    serverProcess.stderr.on('data', (data) => {
      const error = data.toString();
      console.error(`Server Error: ${error}`);
      // 如果是严重错误，拒绝Promise
      if (error.includes('EADDRINUSE') || error.includes('EACCES')) {
        reject(new Error(`服务器启动失败: ${error}`));
      }
    });

    serverProcess.on('close', (code) => {
      console.log(`Server process exited with code ${code}`);
      if (code !== 0 && !serverStarted) {
        reject(new Error(`服务器进程异常退出，退出码: ${code}`));
      }
    });

    serverProcess.on('error', (error) => {
      console.error('Failed to start server:', error);
      reject(new Error(`无法启动服务器进程: ${error.message}`));
    });

    // 给服务器启动时间，如果超时则认为启动成功
    setTimeout(() => {
      if (!serverStarted) {
        console.log('服务器启动超时，假设启动成功');
        serverStarted = true;
        resolve();
      }
    }, 5000);
  });
}

// 创建主窗口
function createWindow() {
  // 创建浏览器窗口
  mainWindow = new BrowserWindow({
    width: 1400,
    height: 900,
    minWidth: 1000,
    minHeight: 700,
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      enableRemoteModule: false,
      preload: path.join(__dirname, 'preload.js')
    },
    icon: path.join(__dirname, 'assets', 'icon.png'), // 如果有图标的话
    show: false, // 先不显示，等加载完成后再显示
    titleBarStyle: 'default',
    autoHideMenuBar: false
  });

  // 窗口准备好后显示
  mainWindow.once('ready-to-show', () => {
    mainWindow.show();
    
    // 开发环境下打开开发者工具
    if (process.env.NODE_ENV === 'development') {
      mainWindow.webContents.openDevTools();
    }
  });

  // 加载应用
  mainWindow.loadURL('http://localhost:3001');

  // 处理窗口关闭
  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  // 处理外部链接
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    shell.openExternal(url);
    return { action: 'deny' };
  });

  // 防止导航到外部网站
  mainWindow.webContents.on('will-navigate', (event, navigationUrl) => {
    const parsedUrl = new URL(navigationUrl);
    
    if (parsedUrl.origin !== 'http://localhost:3001') {
      event.preventDefault();
      shell.openExternal(navigationUrl);
    }
  });
}

// 创建应用菜单
function createMenu() {
  const template = [
    {
      label: '文件',
      submenu: [
        {
          label: '打开下载文件夹',
          click: async () => {
            const downloadsPath = path.join(__dirname, 'downloads');
            if (fs.existsSync(downloadsPath)) {
              shell.openPath(downloadsPath);
            } else {
              dialog.showMessageBox(mainWindow, {
                type: 'info',
                title: '提示',
                message: '下载文件夹不存在',
                detail: '请先下载一些视频文件'
              });
            }
          }
        },
        { type: 'separator' },
        {
          label: '退出',
          accelerator: process.platform === 'darwin' ? 'Cmd+Q' : 'Ctrl+Q',
          click: () => {
            app.quit();
          }
        }
      ]
    },
    {
      label: '编辑',
      submenu: [
        { label: '撤销', accelerator: 'CmdOrCtrl+Z', role: 'undo' },
        { label: '重做', accelerator: 'Shift+CmdOrCtrl+Z', role: 'redo' },
        { type: 'separator' },
        { label: '剪切', accelerator: 'CmdOrCtrl+X', role: 'cut' },
        { label: '复制', accelerator: 'CmdOrCtrl+C', role: 'copy' },
        { label: '粘贴', accelerator: 'CmdOrCtrl+V', role: 'paste' }
      ]
    },
    {
      label: '视图',
      submenu: [
        { label: '重新加载', accelerator: 'CmdOrCtrl+R', role: 'reload' },
        { label: '强制重新加载', accelerator: 'CmdOrCtrl+Shift+R', role: 'forceReload' },
        { label: '开发者工具', accelerator: 'F12', role: 'toggleDevTools' },
        { type: 'separator' },
        { label: '实际大小', accelerator: 'CmdOrCtrl+0', role: 'resetZoom' },
        { label: '放大', accelerator: 'CmdOrCtrl+Plus', role: 'zoomIn' },
        { label: '缩小', accelerator: 'CmdOrCtrl+-', role: 'zoomOut' },
        { type: 'separator' },
        { label: '全屏', accelerator: 'F11', role: 'togglefullscreen' }
      ]
    },
    {
      label: '帮助',
      submenu: [
        {
          label: '关于',
          click: () => {
            dialog.showMessageBox(mainWindow, {
              type: 'info',
              title: '关于',
              message: '视频处理工具',
              detail: '一个基于Electron的视频下载和处理应用\n版本: 1.0.0'
            });
          }
        }
      ]
    }
  ];

  const menu = Menu.buildFromTemplate(template);
  Menu.setApplicationMenu(menu);
}

// 当Electron完成初始化并准备创建浏览器窗口时调用此方法
app.whenReady().then(async () => {
  try {
    // 启动后端服务器
    console.log('正在启动后端服务器...');
    await startServer();
    console.log('后端服务器启动成功');

    // 创建窗口和菜单
    createWindow();
    createMenu();

    app.on('activate', () => {
      // 在macOS上，当点击dock图标并且没有其他窗口打开时，重新创建一个窗口
      if (BrowserWindow.getAllWindows().length === 0) createWindow();
    });
  } catch (error) {
    console.error('启动应用失败:', error);
    
    // 显示更详细的错误信息
    const errorMessage = `无法启动应用服务器\n\n错误详情: ${error.message}\n\n可能的解决方案:\n1. 检查Node.js环境是否正确安装\n2. 检查3001端口是否被占用\n3. 检查应用文件是否完整`;
    
    dialog.showErrorBox('启动错误', errorMessage);
    
    // 尝试延迟重试一次
    console.log('尝试延迟重启服务器...');
    setTimeout(async () => {
      try {
        await startServer();
        console.log('延迟重启成功');
        createWindow();
        createMenu();
      } catch (retryError) {
        console.error('重试失败:', retryError);
        app.quit();
      }
    }, 2000);
  }
});

// 当所有窗口都关闭时退出应用
app.on('window-all-closed', () => {
  // 在macOS上，应用和菜单栏通常会保持活动状态，直到用户明确退出
  if (process.platform !== 'darwin') app.quit();
});

// 应用退出前清理
app.on('before-quit', () => {
  if (serverProcess) {
    console.log('正在关闭后端服务器...');
    serverProcess.kill();
  }
});

// 处理应用退出
app.on('will-quit', (event) => {
  if (serverProcess) {
    event.preventDefault();
    serverProcess.kill();
    setTimeout(() => {
      app.exit();
    }, 1000);
  }
});

// IPC处理程序
ipcMain.handle('get-app-version', () => {
  return app.getVersion();
});

ipcMain.handle('show-save-dialog', async (event, options) => {
  const result = await dialog.showSaveDialog(mainWindow, options);
  return result;
});

ipcMain.handle('show-open-dialog', async (event, options) => {
  const result = await dialog.showOpenDialog(mainWindow, options);
  return result;
});

// 处理重启服务器请求
ipcMain.handle('restart-server', async () => {
  try {
    console.log('收到重启服务器请求');
    
    // 停止当前服务器进程
    if (serverProcess) {
      console.log('正在停止当前服务器进程...');
      serverProcess.kill('SIGTERM');
      
      // 等待进程完全停止
      await new Promise((resolve) => {
        serverProcess.on('close', () => {
          console.log('服务器进程已停止');
          resolve();
        });
        
        // 如果5秒内没有正常退出，强制杀死
        setTimeout(() => {
          if (serverProcess && !serverProcess.killed) {
            console.log('强制停止服务器进程');
            serverProcess.kill('SIGKILL');
          }
          resolve();
        }, 5000);
      });
    }
    
    // 等待一段时间确保端口释放
    await sleep(1000);
    
    // 重新启动服务器
    console.log('正在重新启动服务器...');
    await startServer();
    console.log('服务器重启成功');
    
    return { success: true, message: '服务器重启成功' };
  } catch (error) {
    console.error('重启服务器失败:', error);
    return { success: false, message: `重启失败: ${error.message}` };
  }
});